// 管理员控制器
import jwt from 'jsonwebtoken';
import Admin from './AdminModel.js';
import { redisClient } from '../../db/index.js';
import { asyncHandler, ApiError } from '../../middleware/errorHandler.js';
import UploadService from '../../config/Upload.js';

// JWT密钥
const JWT_SECRET = process.env.JWT_SECRET || 'your_jwt_secret_key';
// Token过期时间（24小时）
const TOKEN_EXPIRY = 60 * 60 * 24;

export const AdminController = {
    /**
     * 管理员登录
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @returns {Promise<Object>} 返回登录结果  
     */
    login: asyncHandler(async (req, res) => {
        const { username, password } = req.body;
        
        if (!username || !password) {
            throw ApiError.badRequest('用户名和密码不能为空');
        }
        
        // 查找管理员
        const admin = await Admin.findOne({ where: { username } });
        if (!admin) {
            throw ApiError.unauthorized('用户名或密码错误');
        }
        
        // 验证密码
        if (!admin.validatePassword(password)) {
            throw ApiError.unauthorized('用户名或密码错误');
        }
        
        // 检查账号状态
        if (admin.status !== 'active') {
            throw ApiError.forbidden('账号已被禁用，请联系超级管理员');
        }
        
        // 生成JWT令牌
        const payload = {
            id: admin.id,
            username: admin.username,
            role: admin.role
        };
        
        const token = jwt.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
        
        // 更新最后登录时间
        await admin.update({ last_login: new Date() });
        
        // 存储到Redis（用于注销功能）
        await redisClient.set(`auth:${admin.id}`, token, { EX: TOKEN_EXPIRY });
        
        return res.json({
            success: true,
            message: '登录成功',
            data: {
                token,
                admin: {
                    id: admin.id,
                    username: admin.username,
                    email: admin.email,
                    avatar: admin.avatar,
                    role: admin.role
                }
            }
        });
    }),
    
    /**
     * 创建管理员账号（仅限超级管理员）
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @returns {Promise<Object>} 返回创建结果
     */
    register: asyncHandler(async (req, res) => {
        const { username, password, email, role, avatar } = req.body;
        
        // 检查必填字段
        if (!username || !password) {
            throw ApiError.badRequest('用户名和密码不能为空');
        }
        
        // 检查用户名是否已存在
        const existingAdmin = await Admin.findOne({ where: { username } });
        if (existingAdmin) {
            throw ApiError.conflict('用户名已存在');
        }
        
        // 创建新管理员
        const newAdmin = await Admin.create({
            username,
            password, // 模型中会自动加密
            email,
            avatar,
            role: role || 'normal'
        });
        
        return res.status(201).json({
            success: true,
            message: '管理员账号创建成功',
            data: {
                id: newAdmin.id,
                username: newAdmin.username,
                email: newAdmin.email,
                avatar: newAdmin.avatar,
                role: newAdmin.role
            }
        });
    }),
    
    /**
     * 管理员登出
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @returns {Promise<Object>} 返回登出结果
     */
    logout: asyncHandler(async (req, res) => {
        const adminId = req.admin.id;
        
        // 从Redis中删除令牌
        await redisClient.del(`auth:${adminId}`);
        
        return res.json({
            success: true,
            message: '登出成功'
        });
    }),
    
    /**
     * 获取当前管理员信息
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @returns {Promise<Object>} 返回管理员信息
     */
    getProfile: asyncHandler(async (req, res) => {
        const adminId = req.admin.id;
        
        const admin = await Admin.findByPk(adminId, {
            attributes: { exclude: ['password'] }
        });
        
        if (!admin) {
            throw ApiError.notFound('管理员不存在');
        }
        
        return res.json({
            success: true,
            data: admin
        });
    }),

    /**
     * 更新管理员头像
     * @param {Object} req - 请求对象
     * @param {Object} res - 响应对象
     * @returns {Promise<Object>} 返回更新结果
     */
    updateAvatar: asyncHandler(async (req, res, next) => {
        // 使用上传服务处理头像上传
        UploadService.imageUploader(req, res, async (err) => {
            if (err) {
                return next(err instanceof ApiError ? err : new ApiError(400, `头像上传失败: ${err.message}`));
            }
            
            if (!req.files || req.files.length === 0) {
                return next(new ApiError(400, '没有上传头像文件'));
            }
            
            const adminId = req.admin.id;
            const admin = await Admin.findByPk(adminId);
            
            if (!admin) {
                return next(ApiError.notFound('管理员不存在'));
            }
            
            // 获取上传的头像URL
            const avatarFile = req.files[0];
            const avatarUrl = `/${avatarFile.destination}/${avatarFile.filename}`;
            
            // 更新管理员头像
            await admin.update({ avatar: avatarUrl });
            
            return res.json({
                success: true,
                message: '头像更新成功',
                data: {
                    avatar: admin.avatar
                }
            });
        });
    })
}